/**
 * @desc 创建某种包装器来接受一个对象并为它定义一些类似数组的行为
 * @param obj
 */
const toKeyedArray = obj => {
	// 利用高阶函数，来定义类数组的各种方法
	const methods = {
		map(target) {
			return callback =>
				Object.keys(target).map(key => callback(target[key], key, target));
		},
		reduce(target) {
			return (callback, accumulator) =>
				Object.keys(target).reduce(
					(acc, key) => callback(acc, target[key], key, target),
					accumulator
				);
		},
		forEach(target) {
			return callback =>
				Object.keys(target).forEach(key => callback(target[key], key, target));
		},
		filter(target) {
			return callback =>
				Object.keys(target).reduce((acc, key) => {
					if (callback(target[key], key, target)) acc[key] = target[key];
					return acc;
				}, {});
		},
		slice(target) {
			return (start, end) => Object.values(target).slice(start, end);
		},
		find(target) {
			return callback => {
				return (Object.entries(target).find(([key, value]) =>
					callback(value, key, target)
				) || [])[0];
			};
		},
		findKey(target) {
			return callback =>
				Object.keys(target).find(key => callback(target[key], key, target));
		},
		includes(target) {
			return val => Object.values(target).includes(val);
		},
		keyOf(target) {
			return value =>
				Object.keys(target).find(key => target[key] === value) || null;
		},
		lastKeyOf(target) {
			return value =>
				Object.keys(target)
				.reverse()
				.find(key => target[key] === value) || null;
		},
	};
	const methodKeys = Object.keys(methods);

	// 定义属性操作
	const handler = {
		get(target, prop, receiver) {
			if (methodKeys.includes(prop)) return methods[prop](...arguments);
			const [keys, values] = [Object.keys(target), Object.values(target)];
			if (prop === 'length') return keys.length;
			if (prop === 'keys') return keys;
			if (prop === 'values') return values;
			// 迭代
			if (prop === Symbol.iterator)
				return function* () {
					for (value of values) yield value;
					return;
				};
			else return Reflect.get(...arguments);
		},
	};

	// 利用 Proxy 拦截，来自定义属性和值
	return new Proxy(obj, handler);
};

// Object creation
const x = toKeyedArray({ a: 'A', b: 'B' });

// Accessing properties and values
x.a;          // 'A'
x.keys;       // ['a', 'b']
x.values;     // ['A', 'B']
[...x];       // ['A', 'B']
x.length;     // 2

// Inserting values
x.c = 'c';    // x = { a: 'A', b: 'B', c: 'c' }
x.length;     // 3

// Array methods
x.forEach((v, i) => console.log(`${i}: ${v}`)); // LOGS: 'a: A', 'b: B', 'c: c'
x.map((v, i) => i + v);                         // ['aA', 'bB, 'cc]
x.filter((v, i) => v !== 'B');                  // { a: 'A', b: 'B' }
x.reduce((a, v, i) => ({ ...a, [v]: i }), {}); 	// { A: 'a', B: 'b', c: 'c' }
x.slice(0, 2);                                  // ['A', 'B']
x.slice(-1);                                    // ['c']
x.find((v, i) => v === i);                      // 'c'
x.findKey((v, i) => v === 'B');                 // 'b'
x.includes('c');                                // true
x.includes('d');                                // false
x.keyOf('B');                                   // 'b'
x.keyOf('a');                                   // null
x.lastKeyOf('c');                               // 'c'

// 6.1 - 30s 代码优化(2)「枚举作用及类」、「对象2数组行为」
//
// 总结关键要点：
// 🎈 枚举类
// 1. class + constructor()
// 2. Object.freeze()
// 3. *[Symbol.iterator]()
// ✨ 1. 永远不会与枚举中的任何值发生冲突
// ✨ 2. 允许将枚举视为可迭代并使其更有用
//
// 🎈 对象2数组行为
// 1. 创建某种包装器来接受一个对象并为它定义一些类似数组的行为
// 2. 利用高阶函数，来定义类数组的各种方法
// ✨ 一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数
//
// 2. new Proxy(obj, handler)
// ✨ 利用 Proxy 拦截，来自定义属性和值
